package com.zhu.transaction.service.imp;

import com.zhu.transaction.mapper.FavoriteMapper;
import com.zhu.transaction.mapper.ProductMapper;
import com.zhu.transaction.mapper.UserMapper;
import com.zhu.transaction.pojo.Product;
import com.zhu.transaction.pojo.ProductCondition;
import com.zhu.transaction.pojo.state.BackState;
import com.zhu.transaction.pojo.state.ProductState;
import com.zhu.transaction.service.ProductService;
import com.zhu.transaction.utils.MyUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @author Zhu
 * @createtime 2021/1/27-9:00
 */
@Service
public class ProductServiceImp implements ProductService {

    @Autowired
    ProductMapper productMapper;

    @Autowired
    FavoriteMapper favoriteMapper;

    @Autowired
    UserMapper userMapper;

    /**
     * 添加商品
     *
     * @param product 商品实体
     * @return 数据库添加结果
     */
    @Override
    public int addProduct(Product product) {
        product.setId(MyUtils.getRandomID()).setShelves(true).setUpdateTime(new Date()).setReleaseTime(new Date());
        //如果商品没有上传图片，使用默认图片
        if (product.getImg() == null || product.getImg().equals(""))
            product.setImg("https://zhu-campus.oss-cn-beijing.aliyuncs.com/products/product_img.svg");
        return productMapper.addProduct(product);
    }

    /**
     * 获取某分类下的所有商品记录
     *
     * @param id 分类ID，0：查询所有
     * @return 商品列表
     */
    @Override
    public List<Product> getAllProduct(String id) {
        return productMapper.queryAllProduct(id);
    }

    /**
     * 获取某个类别下的一页的商品记录
     *
     * @param productCondition 筛选商品条件对象
     * @param num              当前页的记录个数
     * @return 商品记录列表
     */
    @Override
    public List<Product> getProductByPage(ProductCondition productCondition, Integer num) {
        int curPage = productCondition.getCurPage();
        int index = curPage == 0 ? 0 : (curPage - 1) * num;
        List<Product> products = productMapper.queryProductByPage(productCondition, index, num);
        for (Product product : products) {
            product.setReleaseUserPojo(userMapper.queryUserByID(product.getReleaseUser()));
        }
        return products;
    }


    /**
     * 获取商品的详细信息
     *
     * @param productId 商品ID
     * @return 商品实体
     */
    @Override
    public Product getProductDetail(String productId) {
        return productMapper.queryProductByID(productId);
    }

    /**
     * 获取当前用户所有发布的商品记录
     *
     * @param userId  用户ID
     * @param curPage 当前页数
     * @return 商品列表
     */
    @Override
    public List<Product> getMyProducts(String userId, Integer curPage) {
        int index = (curPage - 1) * 3;
        return productMapper.queryProductByUserID(userId, index);
    }

    /**
     * 获取用户收藏的商品
     *
     * @param favoriteIds 收藏ID列表
     * @return 商品列表
     */
    @Override
    public List<Product> getFavoriteProducts(String[] favoriteIds) {
        List<Product> products = new ArrayList<>();
        for (String favoriteId : favoriteIds) {
            Product product = productMapper.queryProductByFavoriteId(favoriteId);
            product.setReleaseUserPojo(userMapper.queryUserByID(product.getReleaseUser()));
            products.add(product);
        }
        return products;
    }

    /**
     * 获取商品的总数量
     *
     * @param userID 用户ID，0：表示获取所有商品的数量，
     *               具体ID：表示该用户发布的所有商品的数量
     * @return 商品数量
     */
    @Override
    public int getProductNum(String userID, ProductCondition productCondition) {
        return productMapper.queryProductNum(userID, productCondition);
    }

    /**
     * 更新商品上架状态
     *
     * @param productId 商品ID
     * @return 状态结果
     */
    @Override
    public BackState updateProductShelves(String productId) {
        int result = productMapper.updateProductShelves(productId);
        Product product = productMapper.queryProductByID(productId);
        if (result > 0 && product != null) {
            if (product.getShelves())
                favoriteMapper.updateProductState(productId, ProductState.SALE);
            else
                favoriteMapper.updateProductState(productId, ProductState.REMOVE);
        }
        return result > 0 ? BackState.SUCCESS : BackState.ERROR;
    }

    /**
     * 更新商品状态
     *
     * @param productId 商品ID
     * @param newState  新的状态
     * @return 更新结果
     */
    @Override
    public BackState updateProductState(String productId, Integer newState) {
        int result = productMapper.updateProductState(productId, newState);
        if (result > 0) {
            favoriteMapper.updateProductState(productId, newState);
        }
        return result > 0 ? BackState.SUCCESS : BackState.ERROR;
    }

    /**
     * 删除商品
     *
     * @param productId 商品ID
     * @return 删除结果
     */
    @Override
    public BackState deleteProduct(String productId, Boolean isLogic) {
        if (!isLogic) {
            int result = productMapper.deleteProductById(productId);
            if (result > 0) {
                favoriteMapper.updateProductState(productId, ProductState.DELETE);
            }
            return result > 0 ? BackState.SUCCESS : BackState.ERROR;
        } else {
            return productMapper.updateDeleteState(productId) > 0 ? BackState.SUCCESS : BackState.ERROR;
        }
    }

    /**
     * 更新商品信息
     *
     * @param product 商品实体
     * @return 更新结果
     */
    @Override
    public BackState updateProduct(Product product) {
        Product tmpProduct = productMapper.queryProductByID(product.getId());
        if (tmpProduct == null) {
            return BackState.NO_EXIST;
        } else {
            product.setUpdateTime(new Date());
            int result = productMapper.updateProduct(product);
            return result > 0 ? BackState.SUCCESS : BackState.ERROR;
        }
    }
}
